When programming extensive computer applications with a high complexity as well as a high flexibility there is a wish to factor out common functionality. Functionality is commonly reused on a “cut and paste” basis and it is difficult to interface between the different constituent components because there is no clear encapsulation of functionality and separation of data and methods. This leads to inconsistencies and low quality, because a reused piece of functionality has no intelligence—it does not know where it came from, and does not synchronize automatically with its progenitor. Furthermore, maintenance is laborious, because the same functionality is repeated, maybe with slight variants, in a lot of places. It takes time to identify all places where an update is required, and the process requires manual intervention and is therefore error-prone.
A way to overcome some of these problems is to use Object Oriented programming. In Object Oriented programming:                Reuse is controlled, as common functionality can be factored out into objects with well-defined interfaces.        Interoperability is facilitated, because objects have well-defined and well-described interfaces.        Variance can be controlled by use of inheritance. Inheritance makes sure that any change to the progenitor will be applied to its descendants.        The level of abstraction is supposedly heightened, as objects should ideally be rooted in the business problem domain, not in the “computer” domain.        
Still,                extending a solution can be a bottleneck, because the programmer is responsible for the infrastructure without which there is no application        
A more structured way of using Object Oriented programming can be provided in a framework. An advantage of a “framework” for application development is that the common functionality is provided in the framework, not in libraries or utility classes. The framework, basically, becomes a framework by providing common functionality plus setting the infrastructure of a working program. However also this kind of programming is also based on inheritance and cannot be easily upgraded.
Within the last couple of years several attempts of creating a framework-based programming language that organizes the programming code for the programmer have been suggested. The overall idea by introducing this programming technique is that all Objects are based on predefined pieces of code. Among others are “Subject-Oriented Programming” by IBM and “Aspect-Oriented Programming” by Xerox PARC Software.
Even though this way of programming helps the programmer organize the objects, the programmer is still responsible for describing how these pieces of functionality interact by writing code from scratch, and writing how these pieces of functionality are combined. This process is also known as “weaving”.
It is a disadvantage of these framework-based programming languages that basically all the weaving has to be redone or at least checked every time the pieces of functionality change. This makes upgrading the framework complicated and expensive.
Furthermore, since some functionality of an object will be provided in the weaving code, it is impossible for the framework to guarantee a system-wide quality of the application, because the framework has no way of knowing what the weaving code does.